package com.ruoyi.system.service.impl;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.system.DTO.Reques.vms.SkuClassDTO;
import com.ruoyi.system.DTO.Reques.vms.SkuClassUpdateDto;
import com.ruoyi.system.mapper.SkuClassDao;
import com.ruoyi.system.pojo.vms.SkuClassEntity;
import com.ruoyi.system.service.SkuClassService;
import com.ruoyi.system.utils.PageResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * Description:
 *
 * @author JourWon
 * @date Created on 2025/5/14
 */
@Service
public class SkuClassServiceImpl implements SkuClassService {

    @Autowired
    private SkuClassDao skuClassDao;

    @DS(value = "slave")
    @Override
    @Transactional
    public Boolean create(SkuClassDTO skuClassDTO) {
        // 检查类型名是否已存在
        LambdaQueryWrapper<SkuClassEntity> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SkuClassEntity::getClassName, skuClassDTO.getClassName());
        if (skuClassDao.selectCount(queryWrapper) > 0) {
            throw new ServiceException("商品类型名称已存在");
        }

        // 转换DTO为Entity
        SkuClassEntity entity = new SkuClassEntity();
        entity.setClassName(skuClassDTO.getClassName());
        entity.setParentId(skuClassDTO.getParentId());

        // 插入数据库
        return skuClassDao.insert(entity) > 0;
    }

    @DS(value = "slave")
    @Override
    public PageResult<SkuClassEntity> search(Integer pageIndex, Integer pageSize, String className) {
        // 设置默认值
        if (pageIndex == null || pageIndex < 1) {
            pageIndex = 1;
        }
        if (pageSize == null || pageSize < 1) {
            pageSize = 10;
        }

        // 计算总数和总页数
        int totalCount = skuClassDao.count(className);
        int totalPage = (int) Math.ceil((double) totalCount / pageSize);

        // 计算偏移量
        int offset = (pageIndex - 1) * pageSize;

        // 查询数据
        List<SkuClassEntity> records = skuClassDao.searchByPage(className, offset, pageSize);

        // 构建返回结果
        PageResult<SkuClassEntity> result = new PageResult<>();
        result.setPageIndex(pageIndex);
        result.setPageSize(pageSize);
        result.setTotalPage(totalPage);
        result.setTotalCount(totalCount);
        result.setCurrentPageRecords(records);

        return result;
    }

    @DS(value = "slave")
    @Override
    public boolean updateSkuClass(Integer classId, SkuClassUpdateDto updateDto) {
        // 检查商品类型是否存在
        SkuClassEntity existingClass = skuClassDao.selectById(classId);
        if (existingClass == null) {
            throw new ServiceException("商品类型不存在");
        }

        // 检查新名称是否已存在（排除自身）
        SkuClassEntity sameNameClass = skuClassDao.selectByClassName(updateDto.getClassName());
        if (sameNameClass != null && !sameNameClass.getClassId().equals(classId)) {
            throw new ServiceException("商品类型名称已存在");
        }

        // 更新商品类型
        int affectedRows = skuClassDao.updateSkuClass(classId, updateDto.getClassName());
        return affectedRows > 0;
    }

    @DS(value = "slave")
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean deleteSkuClass(Integer classId) {
        // 检查商品类型是否存在
        SkuClassEntity skuClass = skuClassDao.selectById(classId);
        if (skuClass == null) {
            throw new ServiceException("商品类型不存在");
        }

        // 检查是否有商品使用该类型
        int skuCount = skuClassDao.countSkusByClassId(classId);
        if (skuCount > 0) {
            throw new ServiceException("该商品类型下存在商品，无法删除");
        }

        // 检查是否有子分类
        int childCount = skuClassDao.countChildrenByParentId(classId);
        if (childCount > 0) {
            throw new ServiceException("该商品类型存在子分类，无法删除");
        }

        // 删除商品类型
        int affectedRows = skuClassDao.deleteById(classId);
        return affectedRows > 0;
    }
}
